home *** CD-ROM | disk | FTP | other *** search
/ PC/CD Gamer UK 120 / CD Gamer Issue 120 (March 2003) (Disc 2).ISO / mods / Q2_Codered / codeRED1_0.exe / Data1.cab / g_spawn.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-13  |  24.3 KB  |  990 lines
  1. /*
  2. Copyright (C) 1997-2001 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20.  
  21. #include "g_local.h"
  22.  
  23. typedef struct
  24. {
  25.     char    *name;
  26.     void    (*spawn)(edict_t *ent);
  27. } spawn_t;
  28.  
  29.  
  30. void SP_item_health (edict_t *self);
  31. void SP_item_health_small (edict_t *self);
  32. void SP_item_health_large (edict_t *self);
  33. void SP_item_health_mega (edict_t *self);
  34.  
  35. void SP_info_player_start (edict_t *ent);
  36. void SP_info_player_deathmatch (edict_t *ent);
  37. void SP_info_player_coop (edict_t *ent);
  38. void SP_info_player_intermission (edict_t *ent);
  39.  
  40. void SP_func_plat (edict_t *ent);
  41. void SP_func_rotating (edict_t *ent);
  42. void SP_func_button (edict_t *ent);
  43. void SP_func_door (edict_t *ent);
  44. void SP_func_door_secret (edict_t *ent);
  45. void SP_func_door_rotating (edict_t *ent);
  46. void SP_func_water (edict_t *ent);
  47. void SP_func_train (edict_t *ent);
  48. void SP_func_conveyor (edict_t *self);
  49. void SP_func_wall (edict_t *self);
  50. void SP_func_object (edict_t *self);
  51. void SP_func_explosive (edict_t *self);
  52. void SP_func_timer (edict_t *self);
  53. void SP_func_areaportal (edict_t *ent);
  54. void SP_func_clock (edict_t *ent);
  55. void SP_func_killbox (edict_t *ent);
  56.  
  57. void SP_trigger_always (edict_t *ent);
  58. void SP_trigger_once (edict_t *ent);
  59. void SP_trigger_multiple (edict_t *ent);
  60. void SP_trigger_relay (edict_t *ent);
  61. void SP_trigger_push (edict_t *ent);
  62. void SP_trigger_hurt (edict_t *ent);
  63. void SP_trigger_key (edict_t *ent);
  64. void SP_trigger_counter (edict_t *ent);
  65. void SP_trigger_elevator (edict_t *ent);
  66. void SP_trigger_gravity (edict_t *ent);
  67. void SP_trigger_monsterjump (edict_t *ent);
  68.  
  69. void SP_target_temp_entity (edict_t *ent);
  70. void SP_target_speaker (edict_t *ent);
  71. void SP_target_explosion (edict_t *ent);
  72. void SP_target_changelevel (edict_t *ent);
  73. void SP_target_secret (edict_t *ent);
  74. void SP_target_goal (edict_t *ent);
  75. void SP_target_splash (edict_t *ent);
  76. void SP_target_spawner (edict_t *ent);
  77. void SP_target_blaster (edict_t *ent);
  78. void SP_target_crosslevel_trigger (edict_t *ent);
  79. void SP_target_crosslevel_target (edict_t *ent);
  80. void SP_target_laser (edict_t *self);
  81. void SP_target_help (edict_t *ent);
  82. void SP_target_actor (edict_t *ent);
  83. void SP_target_lightramp (edict_t *self);
  84. void SP_target_earthquake (edict_t *ent);
  85. void SP_target_character (edict_t *ent);
  86. void SP_target_string (edict_t *ent);
  87.  
  88. void SP_worldspawn (edict_t *ent);
  89. void SP_viewthing (edict_t *ent);
  90.  
  91. void SP_light (edict_t *self);
  92. void SP_light_mine1 (edict_t *ent);
  93. void SP_light_mine2 (edict_t *ent);
  94. void SP_info_null (edict_t *self);
  95. void SP_info_notnull (edict_t *self);
  96. void SP_path_corner (edict_t *self);
  97. void SP_point_combat (edict_t *self);
  98.  
  99. void SP_misc_explobox (edict_t *self);
  100. void SP_misc_banner (edict_t *self);
  101. void SP_misc_satellite_dish (edict_t *self);
  102. void SP_misc_actor (edict_t *self);
  103. void SP_misc_gib_arm (edict_t *self);
  104. void SP_misc_gib_leg (edict_t *self);
  105. void SP_misc_gib_head (edict_t *self);
  106. void SP_misc_insane (edict_t *self);
  107. void SP_misc_deadsoldier (edict_t *self);
  108. void SP_misc_viper (edict_t *self);
  109. void SP_misc_viper_bomb (edict_t *self);
  110. void SP_misc_bigviper (edict_t *self);
  111. void SP_misc_strogg_ship (edict_t *self);
  112. void SP_misc_teleporter (edict_t *self);
  113. void SP_misc_teleporter_dest (edict_t *self);
  114. void SP_misc_blackhole (edict_t *self);
  115. void SP_misc_eastertank (edict_t *self);
  116. void SP_misc_easterchick (edict_t *self);
  117. void SP_misc_easterchick2 (edict_t *self);
  118.  
  119. void SP_monster_berserk (edict_t *self);
  120. void SP_monster_gladiator (edict_t *self);
  121. void SP_monster_gunner (edict_t *self);
  122. void SP_monster_infantry (edict_t *self);
  123. void SP_monster_soldier_light (edict_t *self);
  124. void SP_monster_soldier (edict_t *self);
  125. void SP_monster_soldier_ss (edict_t *self);
  126. void SP_monster_tank (edict_t *self);
  127. void SP_monster_medic (edict_t *self);
  128. void SP_monster_flipper (edict_t *self);
  129. void SP_monster_chick (edict_t *self);
  130. void SP_monster_parasite (edict_t *self);
  131. void SP_monster_flyer (edict_t *self);
  132. void SP_monster_brain (edict_t *self);
  133. void SP_monster_floater (edict_t *self);
  134. void SP_monster_hover (edict_t *self);
  135. void SP_monster_mutant (edict_t *self);
  136. void SP_monster_supertank (edict_t *self);
  137. void SP_monster_boss2 (edict_t *self);
  138. void SP_monster_jorg (edict_t *self);
  139. void SP_monster_boss3_stand (edict_t *self);
  140.  
  141. void SP_monster_commander_body (edict_t *self);
  142.  
  143. void SP_turret_breach (edict_t *self);
  144. void SP_turret_base (edict_t *self);
  145. void SP_turret_driver (edict_t *self);
  146.  
  147.  
  148. spawn_t    spawns[] = {
  149.     {"item_health", SP_item_health},
  150.     {"item_health_small", SP_item_health_small},
  151.     {"item_health_large", SP_item_health_large},
  152.     {"item_health_mega", SP_item_health_mega},
  153.  
  154.     {"info_player_start", SP_info_player_start},
  155.     {"info_player_deathmatch", SP_info_player_deathmatch},
  156.     {"info_player_coop", SP_info_player_coop},
  157.     {"info_player_intermission", SP_info_player_intermission},
  158. //ZOID
  159.     {"info_player_team1", SP_info_player_team1},
  160.     {"info_player_team2", SP_info_player_team2},
  161. //ZOID
  162.  
  163.     {"func_plat", SP_func_plat},
  164.     {"func_button", SP_func_button},
  165.     {"func_door", SP_func_door},
  166.     {"func_door_secret", SP_func_door_secret},
  167.     {"func_door_rotating", SP_func_door_rotating},
  168.     {"func_rotating", SP_func_rotating},
  169.     {"func_train", SP_func_train},
  170.     {"func_water", SP_func_water},
  171.     {"func_conveyor", SP_func_conveyor},
  172.     {"func_areaportal", SP_func_areaportal},
  173.     {"func_clock", SP_func_clock},
  174.     {"func_wall", SP_func_wall},
  175.     {"func_object", SP_func_object},
  176.     {"func_timer", SP_func_timer},
  177.     {"func_explosive", SP_func_explosive},
  178.     {"func_killbox", SP_func_killbox},
  179.  
  180.     {"trigger_always", SP_trigger_always},
  181.     {"trigger_once", SP_trigger_once},
  182.     {"trigger_multiple", SP_trigger_multiple},
  183.     {"trigger_relay", SP_trigger_relay},
  184.     {"trigger_push", SP_trigger_push},
  185.     {"trigger_hurt", SP_trigger_hurt},
  186.     {"trigger_key", SP_trigger_key},
  187.     {"trigger_counter", SP_trigger_counter},
  188.     {"trigger_elevator", SP_trigger_elevator},
  189.     {"trigger_gravity", SP_trigger_gravity},
  190.     {"trigger_monsterjump", SP_trigger_monsterjump},
  191.  
  192.     {"target_temp_entity", SP_target_temp_entity},
  193.     {"target_speaker", SP_target_speaker},
  194.     {"target_explosion", SP_target_explosion},
  195.     {"target_changelevel", SP_target_changelevel},
  196.     {"target_secret", SP_target_secret},
  197.     {"target_goal", SP_target_goal},
  198.     {"target_splash", SP_target_splash},
  199.     {"target_spawner", SP_target_spawner},
  200.     {"target_blaster", SP_target_blaster},
  201.     {"target_crosslevel_trigger", SP_target_crosslevel_trigger},
  202.     {"target_crosslevel_target", SP_target_crosslevel_target},
  203.     {"target_laser", SP_target_laser},
  204.     {"target_help", SP_target_help},
  205. #if 0 // remove monster code
  206.     {"target_actor", SP_target_actor},
  207. #endif
  208.     {"target_lightramp", SP_target_lightramp},
  209.     {"target_earthquake", SP_target_earthquake},
  210.     {"target_character", SP_target_character},
  211.     {"target_string", SP_target_string},
  212.  
  213.     {"worldspawn", SP_worldspawn},
  214.     {"viewthing", SP_viewthing},
  215.  
  216.     {"light", SP_light},
  217.     {"light_mine1", SP_light_mine1},
  218.     {"light_mine2", SP_light_mine2},
  219.     {"info_null", SP_info_null},
  220.     {"func_group", SP_info_null},
  221.     {"info_notnull", SP_info_notnull},
  222.     {"path_corner", SP_path_corner},
  223.     {"point_combat", SP_point_combat},
  224.  
  225.     {"misc_explobox", SP_misc_explobox},
  226.     {"misc_banner", SP_misc_banner},
  227. //ZOID
  228.     {"misc_ctf_banner", SP_misc_ctf_banner},
  229.     {"misc_ctf_small_banner", SP_misc_ctf_small_banner},
  230. //ZOID
  231.     {"misc_satellite_dish", SP_misc_satellite_dish},
  232. #if 0 // remove monster code
  233.     {"misc_actor", SP_misc_actor},
  234. #endif
  235.     {"misc_gib_arm", SP_misc_gib_arm},
  236.     {"misc_gib_leg", SP_misc_gib_leg},
  237.     {"misc_gib_head", SP_misc_gib_head},
  238. #if 0 // remove monster code
  239.     {"misc_insane", SP_misc_insane},
  240. #endif
  241.     {"misc_deadsoldier", SP_misc_deadsoldier},
  242.     {"misc_viper", SP_misc_viper},
  243.     {"misc_viper_bomb", SP_misc_viper_bomb},
  244.     {"misc_bigviper", SP_misc_bigviper},
  245.     {"misc_strogg_ship", SP_misc_strogg_ship},
  246.     {"misc_teleporter", SP_misc_teleporter},
  247.     {"misc_teleporter_dest", SP_misc_teleporter_dest},
  248. //ZOID
  249.     {"trigger_teleport", SP_trigger_teleport},
  250.     {"info_teleport_destination", SP_info_teleport_destination},
  251. //ZOID
  252.     {"misc_blackhole", SP_misc_blackhole},
  253.     {"misc_eastertank", SP_misc_eastertank},
  254.     {"misc_easterchick", SP_misc_easterchick},
  255.     {"misc_easterchick2", SP_misc_easterchick2},
  256.  
  257. #if 0 // remove monster code
  258.     {"monster_berserk", SP_monster_berserk},
  259.     {"monster_gladiator", SP_monster_gladiator},
  260.     {"monster_gunner", SP_monster_gunner},
  261.     {"monster_infantry", SP_monster_infantry},
  262.     {"monster_soldier_light", SP_monster_soldier_light},
  263.     {"monster_soldier", SP_monster_soldier},
  264.     {"monster_soldier_ss", SP_monster_soldier_ss},
  265.     {"monster_tank", SP_monster_tank},
  266.     {"monster_tank_commander", SP_monster_tank},
  267.     {"monster_medic", SP_monster_medic},
  268.     {"monster_flipper", SP_monster_flipper},
  269.     {"monster_chick", SP_monster_chick},
  270.     {"monster_parasite", SP_monster_parasite},
  271.     {"monster_flyer", SP_monster_flyer},
  272.     {"monster_brain", SP_monster_brain},
  273.     {"monster_floater", SP_monster_floater},
  274.     {"monster_hover", SP_monster_hover},
  275.     {"monster_mutant", SP_monster_mutant},
  276.     {"monster_supertank", SP_monster_supertank},
  277.     {"monster_boss2", SP_monster_boss2},
  278.     {"monster_boss3_stand", SP_monster_boss3_stand},
  279.     {"monster_jorg", SP_monster_jorg},
  280.  
  281.     {"monster_commander_body", SP_monster_commander_body},
  282.  
  283.     {"turret_breach", SP_turret_breach},
  284.     {"turret_base", SP_turret_base},
  285.     {"turret_driver", SP_turret_driver},
  286. #endif
  287.  
  288.     {NULL, NULL}
  289. };
  290.  
  291. /*
  292. ===============
  293. ED_CallSpawn
  294.  
  295. Finds the spawn function for the entity and calls it
  296. ===============
  297. */
  298. void ED_CallSpawn (edict_t *ent)
  299. {
  300.     spawn_t    *s;
  301.     gitem_t    *item;
  302.     int        i;
  303.  
  304.     if (!ent->classname)
  305.     {
  306.         gi.dprintf ("ED_CallSpawn: NULL classname\n");
  307.         return;
  308.     }
  309.  
  310.     // check item spawn functions
  311.     for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
  312.     {
  313.         if (!item->classname)
  314.             continue;
  315.         if (!strcmp(item->classname, ent->classname))
  316.         {    // found it
  317.             SpawnItem (ent, item);
  318.             return;
  319.         }
  320.     }
  321.  
  322.     // check normal spawn functions
  323.     for (s=spawns ; s->name ; s++)
  324.     {
  325.         if (!strcmp(s->name, ent->classname))
  326.         {    // found it
  327.             s->spawn (ent);
  328.             return;
  329.         }
  330.     }
  331.     gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
  332. }
  333.  
  334. /*
  335. =============
  336. ED_NewString
  337. =============
  338. */
  339. char *ED_NewString (char *string)
  340. {
  341.     char    *newb, *new_p;
  342.     int        i,l;
  343.     
  344.     l = strlen(string) + 1;
  345.  
  346.     newb = gi.TagMalloc (l, TAG_LEVEL);
  347.  
  348.     new_p = newb;
  349.  
  350.     for (i=0 ; i< l ; i++)
  351.     {
  352.         if (string[i] == '\\' && i < l-1)
  353.         {
  354.             i++;
  355.             if (string[i] == 'n')
  356.                 *new_p++ = '\n';
  357.             else
  358.                 *new_p++ = '\\';
  359.         }
  360.         else
  361.             *new_p++ = string[i];
  362.     }
  363.     
  364.     return newb;
  365. }
  366.  
  367.  
  368.  
  369.  
  370. /*
  371. ===============
  372. ED_ParseField
  373.  
  374. Takes a key/value pair and sets the binary values
  375. in an edict
  376. ===============
  377. */
  378. void ED_ParseField (char *key, char *value, edict_t *ent)
  379. {
  380.     field_t    *f;
  381.     byte    *b;
  382.     float    v;
  383.     vec3_t    vec;
  384.  
  385.     for (f=fields ; f->name ; f++)
  386.     {
  387.         if (!Q_stricmp(f->name, key))
  388.         {    // found it
  389.             if (f->flags & FFL_SPAWNTEMP)
  390.                 b = (byte *)&st;
  391.             else
  392.                 b = (byte *)ent;
  393.  
  394.             switch (f->type)
  395.             {
  396.             case F_LSTRING:
  397.                 *(char **)(b+f->ofs) = ED_NewString (value);
  398.                 break;
  399.             case F_VECTOR:
  400.                 sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
  401.                 ((float *)(b+f->ofs))[0] = vec[0];
  402.                 ((float *)(b+f->ofs))[1] = vec[1];
  403.                 ((float *)(b+f->ofs))[2] = vec[2];
  404.                 break;
  405.             case F_INT:
  406.                 *(int *)(b+f->ofs) = atoi(value);
  407.                 break;
  408.             case F_FLOAT:
  409.                 *(float *)(b+f->ofs) = atof(value);
  410.                 break;
  411.             case F_ANGLEHACK:
  412.                 v = atof(value);
  413.                 ((float *)(b+f->ofs))[0] = 0;
  414.                 ((float *)(b+f->ofs))[1] = v;
  415.                 ((float *)(b+f->ofs))[2] = 0;
  416.                 break;
  417.             case F_IGNORE:
  418.                 break;
  419.             }
  420.             return;
  421.         }
  422.     }
  423.     gi.dprintf ("%s is not a field\n", key);
  424. }
  425.  
  426. /*
  427. ====================
  428. ED_ParseEdict
  429.  
  430. Parses an edict out of the given string, returning the new position
  431. ed should be a properly initialized empty edict.
  432. ====================
  433. */
  434. char *ED_ParseEdict (char *data, edict_t *ent)
  435. {
  436.     qboolean    init;
  437.     char        keyname[256];
  438.     char        *com_token;
  439.  
  440.     init = false;
  441.     memset (&st, 0, sizeof(st));
  442.  
  443. // go through all the dictionary pairs
  444.     while (1)
  445.     {    
  446.     // parse key
  447.         com_token = COM_Parse (&data);
  448.         if (com_token[0] == '}')
  449.             break;
  450.         if (!data)
  451.             gi.error ("ED_ParseEntity: EOF without closing brace");
  452.  
  453.         strncpy (keyname, com_token, sizeof(keyname)-1);
  454.         
  455.     // parse value    
  456.         com_token = COM_Parse (&data);
  457.         if (!data)
  458.             gi.error ("ED_ParseEntity: EOF without closing brace");
  459.  
  460.         if (com_token[0] == '}')
  461.             gi.error ("ED_ParseEntity: closing brace without data");
  462.  
  463.         init = true;    
  464.  
  465.     // keynames with a leading underscore are used for utility comments,
  466.     // and are immediately discarded by quake
  467.         if (keyname[0] == '_')
  468.             continue;
  469.  
  470.         ED_ParseField (keyname, com_token, ent);
  471.     }
  472.  
  473.     if (!init)
  474.         memset (ent, 0, sizeof(*ent));
  475.  
  476.     return data;
  477. }
  478.  
  479.  
  480. /*
  481. ================
  482. G_FindTeams
  483.  
  484. Chain together all entities with a matching team field.
  485.  
  486. All but the first will have the FL_TEAMSLAVE flag set.
  487. All but the last will have the teamchain field set to the next one
  488. ================
  489. */
  490. void G_FindTeams (void)
  491. {
  492.     edict_t    *e, *e2, *chain;
  493.     int        i, j;
  494.     int        c, c2;
  495.  
  496.     c = 0;
  497.     c2 = 0;
  498.     for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
  499.     {
  500.         if (!e->inuse)
  501.             continue;
  502.         if (!e->team)
  503.             continue;
  504.         if (e->flags & FL_TEAMSLAVE)
  505.             continue;
  506.         chain = e;
  507.         e->teammaster = e;
  508.         c++;
  509.         c2++;
  510.         for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++)
  511.         {
  512.             if (!e2->inuse)
  513.                 continue;
  514.             if (!e2->team)
  515.                 continue;
  516.             if (e2->flags & FL_TEAMSLAVE)
  517.                 continue;
  518.             if (!strcmp(e->team, e2->team))
  519.             {
  520.                 c2++;
  521.                 chain->teamchain = e2;
  522.                 e2->teammaster = e;
  523.                 chain = e2;
  524.                 e2->flags |= FL_TEAMSLAVE;
  525.             }
  526.         }
  527.     }
  528.  
  529.     gi.dprintf ("%i teams with %i entities\n", c, c2);
  530. }
  531.  
  532. /*
  533. ==============
  534. SpawnEntities
  535.  
  536. Creates a server's entity / program execution context by
  537. parsing textual entity definitions out of an ent file.
  538. ==============
  539. */
  540. void SpawnEntities (char *mapname, char *entities, char *spawnpoint)
  541. {
  542.     edict_t        *ent;
  543.     int            inhibit;
  544.     char        *com_token;
  545.     int            i;
  546.     float        skill_level;
  547.  
  548.     skill_level = floor (skill->value);
  549.     if (skill_level < 0)
  550.         skill_level = 0;
  551.     if (skill_level > 3)
  552.         skill_level = 3;
  553.     if (skill->value != skill_level)
  554.         gi.cvar_forceset("skill", va("%f", skill_level));
  555.  
  556.     SaveClientData ();
  557.  
  558.     gi.FreeTags (TAG_LEVEL);
  559.  
  560.     memset (&level, 0, sizeof(level));
  561.     memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0]));
  562.  
  563.     strncpy (level.mapname, mapname, sizeof(level.mapname)-1);
  564.     strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1);
  565.  
  566.     // set client fields on player ents
  567.     for (i=0 ; i<game.maxclients ; i++)
  568.         g_edicts[i+1].client = game.clients + i;
  569.  
  570.     ent = NULL;
  571.     inhibit = 0;
  572.  
  573. // parse ents
  574.     while (1)
  575.     {
  576.         // parse the opening brace    
  577.         com_token = COM_Parse (&entities);
  578.         if (!entities)
  579.             break;
  580.         if (com_token[0] != '{')
  581.             gi.error ("ED_LoadFromFile: found %s when expecting {",com_token);
  582.  
  583.         if (!ent)
  584.             ent = g_edicts;
  585.         else
  586.             ent = G_Spawn ();
  587.         entities = ED_ParseEdict (entities, ent);
  588.         
  589.         // yet another map hack
  590.         if (!stricmp(level.mapname, "command") && !stricmp(ent->classname, "trigger_once") && !stricmp(ent->model, "*27"))
  591.             ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
  592.  
  593.         // remove things (except the world) from different skill levels or deathmatch
  594.         if (ent != g_edicts)
  595.         {
  596.             if (deathmatch->value)
  597.             {
  598.                 if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
  599.                 {
  600.                     G_FreeEdict (ent);    
  601.                     inhibit++;
  602.                     continue;
  603.                 }
  604.             }
  605.             else
  606.             {
  607.                 if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
  608.                     ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
  609.                     ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
  610.                     (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
  611.                     )
  612.                     {
  613.                         G_FreeEdict (ent);    
  614.                         inhibit++;
  615.                         continue;
  616.                     }
  617.             }
  618.  
  619.             ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
  620.         }
  621.  
  622.         ED_CallSpawn (ent);
  623.     }    
  624.  
  625.     gi.dprintf ("%i entities inhibited\n", inhibit);
  626.  
  627.     G_FindTeams ();
  628.  
  629.     PlayerTrail_Init ();
  630.  
  631. //ZOID
  632.     CTFSpawn();
  633. //ZOID
  634. }
  635.  
  636.  
  637. //===================================================================
  638.  
  639. #if 0
  640.     // cursor positioning
  641.     xl <value>
  642.     xr <value>
  643.     yb <value>
  644.     yt <value>
  645.     xv <value>
  646.     yv <value>
  647.  
  648.     // drawing
  649.     statpic <name>
  650.     pic <stat>
  651.     num <fieldwidth> <stat>
  652.     string <stat>
  653.  
  654.     // control
  655.     if <stat>
  656.     ifeq <stat> <value>
  657.     ifbit <stat> <value>
  658.     endif
  659.  
  660. #endif
  661.  
  662. char *single_statusbar = 
  663. "yb    -24 "
  664.  
  665. // health
  666. "xv    0 "
  667. "hnum "
  668. "xv    50 "
  669. "pic 0 "
  670.  
  671. // ammo
  672. "if 2 "
  673. "    xv    100 "
  674. "    anum "
  675. "    xv    150 "
  676. "    pic 2 "
  677. "endif "
  678.  
  679. // armor
  680. "if 4 "
  681. "    xv    200 "
  682. "    rnum "
  683. "    xv    250 "
  684. "    pic 4 "
  685. "endif "
  686.  
  687. // selected item
  688. "if 6 "
  689. "    xv    296 "
  690. "    pic 6 "
  691. "endif "
  692.  
  693. "yb    -50 "
  694.  
  695. // picked up item
  696. "if 7 "
  697. "    xv    0 "
  698. "    pic 7 "
  699. "    xv    26 "
  700. "    yb    -42 "
  701. "    stat_string 8 "
  702. "    yb    -50 "
  703. "endif "
  704.  
  705. // timer
  706. "if 9 "
  707. "    xv    262 "
  708. "    num    2    10 "
  709. "    xv    296 "
  710. "    pic    9 "
  711. "endif "
  712.  
  713. //  help / weapon icon 
  714. "if 11 "
  715. "    xv    148 "
  716. "    pic    11 "
  717. "endif "
  718. ;
  719.  
  720. char *dm_statusbar =
  721. "yb    -24 "
  722.  
  723. // health
  724. "xv    0 "
  725. "hnum "
  726. "xv    50 "
  727. "pic 0 "
  728.  
  729. // ammo
  730. "if 2 "
  731. "    xv    100 "
  732. "    anum "
  733. "    xv    150 "
  734. "    pic 2 "
  735. "endif "
  736.  
  737. // armor
  738. "if 4 "
  739. "    xv    200 "
  740. "    rnum "
  741. "    xv    250 "
  742. "    pic 4 "
  743. "endif "
  744.  
  745. // selected item
  746. "if 6 "
  747. "    xv    296 "
  748. "    pic 6 "
  749. "endif "
  750.  
  751. "yb    -50 "
  752.  
  753. // picked up item
  754. "if 7 "
  755. "    xv    0 "
  756. "    pic 7 "
  757. "    xv    26 "
  758. "    yb    -42 "
  759. "    stat_string 8 "
  760. "    yb    -50 "
  761. "endif "
  762.  
  763. // timer
  764. "if 9 "
  765. "    xv    246 "
  766. "    num    2    10 "
  767. "    xv    296 "
  768. "    pic    9 "
  769. "endif "
  770.  
  771. //  help / weapon icon 
  772. "if 11 "
  773. "    xv    148 "
  774. "    pic    11 "
  775. "endif "
  776.  
  777. //  frags
  778. "xr    -50 "
  779. "yt 2 "
  780. "num 3 14"
  781. ;
  782.  
  783.  
  784. /*QUAKED worldspawn (0 0 0) ?
  785.  
  786. Only used for the world.
  787. "sky"    environment map name
  788. "skyaxis"    vector axis for rotating sky
  789. "skyrotate"    speed of rotation in degrees/second
  790. "sounds"    music cd track number
  791. "gravity"    800 is default gravity
  792. "message"    text to print at user logon
  793. */
  794. void SP_worldspawn (edict_t *ent)
  795. {
  796.     ent->movetype = MOVETYPE_PUSH;
  797.     ent->solid = SOLID_BSP;
  798.     ent->inuse = true;            // since the world doesn't use G_Spawn()
  799.     ent->s.modelindex = 1;        // world model is always index 1
  800.  
  801.     //---------------
  802.  
  803.     // reserve some spots for dead player bodies for coop / deathmatch
  804.     InitBodyQue ();
  805.  
  806.     // set configstrings for items
  807.     SetItemNames ();
  808.  
  809.     if (st.nextmap)
  810.         strcpy (level.nextmap, st.nextmap);
  811.  
  812.     // make some data visible to the server
  813.  
  814.     if (ent->message && ent->message[0])
  815.     {
  816.         gi.configstring (CS_NAME, ent->message);
  817.         strncpy (level.level_name, ent->message, sizeof(level.level_name));
  818.     }
  819.     else
  820.         strncpy (level.level_name, level.mapname, sizeof(level.level_name));
  821.  
  822.     if (st.sky && st.sky[0])
  823.         gi.configstring (CS_SKY, st.sky);
  824.     else
  825.         gi.configstring (CS_SKY, "unit1_");
  826.  
  827.     gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
  828.  
  829.     gi.configstring (CS_SKYAXIS, va("%f %f %f",
  830.         st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
  831.  
  832.     gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
  833.  
  834.     gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
  835.  
  836.     // status bar program
  837.     if (deathmatch->value)
  838. //ZOID
  839.         if (ctf->value) {
  840.             gi.configstring (CS_STATUSBAR, ctf_statusbar);
  841.             CTFPrecache();
  842.         } else
  843. //ZOID
  844.             gi.configstring (CS_STATUSBAR, dm_statusbar);
  845.     else
  846.         gi.configstring (CS_STATUSBAR, single_statusbar);
  847.  
  848.     //---------------
  849.  
  850.  
  851.     // help icon for statusbar
  852.     gi.imageindex ("i_help");
  853.     level.pic_health = gi.imageindex ("i_health");
  854.     gi.imageindex ("help");
  855.     gi.imageindex ("field_3");
  856.  
  857.     if (!st.gravity)
  858.         gi.cvar_set("sv_gravity", "800");
  859.     else
  860.         gi.cvar_set("sv_gravity", st.gravity);
  861.  
  862.     snd_fry = gi.soundindex ("player/fry.wav");    // standing in lava / slime
  863.  
  864.     PrecacheItem (FindItem ("Blaster"));
  865.  
  866.     gi.soundindex ("player/lava1.wav");
  867.     gi.soundindex ("player/lava2.wav");
  868.  
  869.     gi.soundindex ("misc/pc_up.wav");
  870.     gi.soundindex ("misc/talk1.wav");
  871.  
  872.     gi.soundindex ("misc/udeath.wav");
  873.  
  874.     // gibs
  875.     gi.soundindex ("items/respawn1.wav");
  876.  
  877.     // sexed sounds
  878.     gi.soundindex ("*death1.wav");
  879.     gi.soundindex ("*death2.wav");
  880.     gi.soundindex ("*death3.wav");
  881.     gi.soundindex ("*death4.wav");
  882.     gi.soundindex ("*fall1.wav");
  883.     gi.soundindex ("*fall2.wav");    
  884.     gi.soundindex ("*gurp1.wav");        // drowning damage
  885.     gi.soundindex ("*gurp2.wav");    
  886.     gi.soundindex ("*jump1.wav");        // player jump
  887.     gi.soundindex ("*pain25_1.wav");
  888.     gi.soundindex ("*pain25_2.wav");
  889.     gi.soundindex ("*pain50_1.wav");
  890.     gi.soundindex ("*pain50_2.wav");
  891.     gi.soundindex ("*pain75_1.wav");
  892.     gi.soundindex ("*pain75_2.wav");
  893.     gi.soundindex ("*pain100_1.wav");
  894.     gi.soundindex ("*pain100_2.wav");
  895.  
  896.     // sexed models
  897.     // THIS ORDER MUST MATCH THE DEFINES IN g_local.h
  898.     // you can add more, max 15
  899.     gi.modelindex ("#w_blaster.md2");
  900.     gi.modelindex ("#w_shotgun.md2");
  901.     gi.modelindex ("#w_sshotgun.md2");
  902.     gi.modelindex ("#w_machinegun.md2");
  903.     gi.modelindex ("#w_chaingun.md2");
  904.     gi.modelindex ("#a_grenades.md2");
  905.     gi.modelindex ("#w_glauncher.md2");
  906.     gi.modelindex ("#w_rlauncher.md2");
  907.     gi.modelindex ("#w_hyperblaster.md2");
  908.     gi.modelindex ("#w_railgun.md2");
  909.     gi.modelindex ("#w_bfg.md2");
  910.     gi.modelindex ("#w_grapple.md2");
  911.  
  912.     //-------------------
  913.  
  914.     gi.soundindex ("player/gasp1.wav");        // gasping for air
  915.     gi.soundindex ("player/gasp2.wav");        // head breaking surface, not gasping
  916.  
  917.     gi.soundindex ("player/watr_in.wav");    // feet hitting water
  918.     gi.soundindex ("player/watr_out.wav");    // feet leaving water
  919.  
  920.     gi.soundindex ("player/watr_un.wav");    // head going underwater
  921.     
  922.     gi.soundindex ("player/u_breath1.wav");
  923.     gi.soundindex ("player/u_breath2.wav");
  924.  
  925.     gi.soundindex ("items/pkup.wav");        // bonus item pickup
  926.     gi.soundindex ("world/land.wav");        // landing thud
  927.     gi.soundindex ("misc/h2ohit1.wav");        // landing splash
  928.  
  929.     gi.soundindex ("items/damage.wav");
  930.     gi.soundindex ("items/protect.wav");
  931.     gi.soundindex ("items/protect4.wav");
  932.     gi.soundindex ("weapons/noammo.wav");
  933.  
  934.     gi.soundindex ("infantry/inflies1.wav");
  935.  
  936.     sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
  937.     gi.modelindex ("models/objects/gibs/arm/tris.md2");
  938.     gi.modelindex ("models/objects/gibs/bone/tris.md2");
  939.     gi.modelindex ("models/objects/gibs/bone2/tris.md2");
  940.     gi.modelindex ("models/objects/gibs/chest/tris.md2");
  941.     gi.modelindex ("models/objects/gibs/skull/tris.md2");
  942.     gi.modelindex ("models/objects/gibs/head2/tris.md2");
  943.  
  944. //
  945. // Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
  946. //
  947.  
  948.     // 0 normal
  949.     gi.configstring(CS_LIGHTS+0, "m");
  950.     
  951.     // 1 FLICKER (first variety)
  952.     gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
  953.     
  954.     // 2 SLOW STRONG PULSE
  955.     gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
  956.     
  957.     // 3 CANDLE (first variety)
  958.     gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
  959.     
  960.     // 4 FAST STROBE
  961.     gi.configstring(CS_LIGHTS+4, "mamamamamama");
  962.     
  963.     // 5 GENTLE PULSE 1
  964.     gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
  965.     
  966.     // 6 FLICKER (second variety)
  967.     gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
  968.     
  969.     // 7 CANDLE (second variety)
  970.     gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
  971.     
  972.     // 8 CANDLE (third variety)
  973.     gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
  974.     
  975.     // 9 SLOW STROBE (fourth variety)
  976.     gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
  977.     
  978.     // 10 FLUORESCENT FLICKER
  979.     gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
  980.  
  981.     // 11 SLOW PULSE NOT FADE TO BLACK
  982.     gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
  983.     
  984.     // styles 32-62 are assigned by the light program for switchable lights
  985.  
  986.     // 63 testing
  987.     gi.configstring(CS_LIGHTS+63, "a");
  988. }
  989.  
  990.